package org.elsfs.cloud.common.mybatis.ext.sql;



import org.elsfs.cloud.common.mybatis.ext.sql.support.builder.StandardSelectSql;

import java.util.Collection;
import java.util.function.Consumer;

/**
 * SQL条件接口
 *
 * @param <C> 子类具体类型
 */
@SuppressWarnings("unchecked")
public interface Condition<C extends Condition<C>> extends SqlFragment {

    /**
     * 相等条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C eq(String leftField, String rightField);

    /**
     * 相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C eq(Enum<?> leftField, Enum<?> rightField);

    /**
     * 相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C eq(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C eq(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

    /**
     * 相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C eq(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 相等条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C eq(String leftField, Enum<?> rightField);

    /**
     * 相等条件
     *
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C eq(String leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C eq(Enum<?> leftField, String rightField);

    /**
     * 相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C eq(String leftTableAlias, Enum<?> leftField, String rightField);

    /**
     * 相等条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C eq(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 相等条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C eq(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C eq(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 相等条件
     *
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    C eqValue(String leftField, Object rightValue);

    /**
     * 相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C eqValue(Enum<?> leftField, Object rightValue);

    /**
     * 相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C eqValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C ne(String leftField, String rightField);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ne(Enum<?> leftField, Enum<?> rightField);

    /**
     * 不相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ne(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 不相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ne(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ne(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ne(String leftField, Enum<?> rightField);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ne(String leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C ne(Enum<?> leftField, String rightField);

    /**
     * 不相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C ne(String leftTableAlias, Enum<?> leftField, String rightField);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C ne(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C ne(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 不相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C ne(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    C neValue(String leftField, Object rightValue);

    /**
     * 不相等条件
     *
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C neValue(Enum<?> leftField, Object rightValue);

    /**
     * 不相等条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C neValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

    /**
     * 小于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C lt(String leftField, String rightField);

    /**
     * 小于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C lt(Enum<?> leftField, Enum<?> rightField);

    /**
     * 小于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C lt(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 小于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C lt(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

    /**
     * 小于条件
     *
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C lt(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 小于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C lt(String leftField, Enum<?> rightField);

    /**
     * 小于条件
     *
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C lt(String leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 小于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C lt(Enum<?> leftField, String rightField);

    /**
     * 小于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C lt(String leftTableAlias, Enum<?> leftField, String rightField);

    /**
     * 小于条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C lt(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 小于条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C lt(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 小于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C lt(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 小于条件
     *
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    C ltValue(String leftField, Object rightValue);

    /**
     * 小于条件
     *
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C ltValue(Enum<?> leftField, Object rightValue);

    /**
     * 小于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C ltValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C le(String leftField, String rightField);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C le(Enum<?> leftField, Enum<?> rightField);

    /**
     * 小于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C le(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 小于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C le(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C le(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C le(String leftField, Enum<?> rightField);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C le(String leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C le(Enum<?> leftField, String rightField);

    /**
     * 小于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C le(String leftTableAlias, Enum<?> leftField, String rightField);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C le(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C le(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 小于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C le(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    C leValue(String leftField, Object rightValue);

    /**
     * 小于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C leValue(Enum<?> leftField, Object rightValue);

    /**
     * 小于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C leValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

    /**
     * 大于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C gt(String leftField, String rightField);

    /**
     * 大于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C gt(Enum<?> leftField, Enum<?> rightField);

    /**
     * 大于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C gt(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 大于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C gt(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

    /**
     * 大于条件
     *
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C gt(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 大于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C gt(String leftField, Enum<?> rightField);

    /**
     * 大于条件
     *
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C gt(String leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 大于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C gt(Enum<?> leftField, String rightField);

    /**
     * 大于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C gt(String leftTableAlias, Enum<?> leftField, String rightField);

    /**
     * 大于条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C gt(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 大于条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C gt(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 大于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C gt(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 大于条件
     *
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    C gtValue(String leftField, Object rightValue);

    /**
     * 大于条件
     *
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C gtValue(Enum<?> leftField, Object rightValue);

    /**
     * 大于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C gtValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C ge(String leftField, String rightField);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ge(Enum<?> leftField, Enum<?> rightField);

    /**
     * 大于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ge(String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 大于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ge(String leftTableAlias, Enum<?> leftField, Enum<?> rightField);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ge(Enum<?> leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ge(String leftField, Enum<?> rightField);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    C ge(String leftField, String rightTableAlias, Enum<?> rightField);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C ge(Enum<?> leftField, String rightField);

    /**
     * 大于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    C ge(String leftTableAlias, Enum<?> leftField, String rightField);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C ge(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C ge(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 大于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C ge(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    C geValue(String leftField, Object rightValue);

    /**
     * 大于等于条件
     *
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C geValue(Enum<?> leftField, Object rightValue);

    /**
     * 大于等于条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    C geValue(String leftTableAlias, Enum<?> leftField, Object rightValue);

    /**
     * 区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    C between(String leftField, String beginField, String endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C between(String leftField, Enum<?> beginField, Enum<?> endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C between(String leftField, String beginField, Enum<?> endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    C between(String leftField, Enum<?> beginField, String endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C between(Enum<?> leftField, Enum<?> beginField, Enum<?> endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C between(Enum<?> leftField, String beginField, Enum<?> endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段
     * @return 具体实现
     */
    C between(Enum<?> leftField, Enum<?> beginField, String endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    C betweenBeginValue(String leftField, Object beginValue, String endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C betweenBeginValue(Enum<?> leftField, Object beginValue, Enum<?> endField);

    /**
     * 区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C betweenEndValue(String leftField, String beginField, Object endValue);

    /**
     * 区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C betweenEndValue(Enum<?> leftField, Enum<?> beginField, Object endValue);

    /**
     * 区间条件
     *
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C betweenValue(String leftField, Object beginValue, Object endValue);

    /**
     * 区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C betweenValue(Enum<?> leftField, Object beginValue, Object endValue);

    /**
     * 区间条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C betweenValue(String leftTableAlias, Enum<?> leftField, Object beginValue, Object endValue);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    C notBetween(String leftField, String beginField, String endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C notBetween(String leftField, Enum<?> beginField, Enum<?> endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C notBetween(String leftField, String beginField, Enum<?> endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    C notBetween(String leftField, Enum<?> beginField, String endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C notBetween(Enum<?> leftField, Enum<?> beginField, Enum<?> endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C notBetween(Enum<?> leftField, String beginField, Enum<?> endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段
     * @return 具体实现
     */
    C notBetween(Enum<?> leftField, Enum<?> beginField, String endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    C notBetweenBeginValue(String leftField, Object beginValue, String endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    C notBetweenBeginValue(Enum<?> leftField, Object beginValue, Enum<?> endField);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C notBetweenEndValue(String leftField, String beginField, Object endValue);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C notBetweenEndValue(Enum<?> leftField, Enum<?> beginField, Object endValue);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C notBetweenValue(String leftField, Object beginValue, Object endValue);

    /**
     * 非区间条件
     *
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C notBetweenValue(Enum<?> leftField, Object beginValue, Object endValue);

    /**
     * 非区间条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    C notBetweenValue(String leftTableAlias, Enum<?> leftField, Object beginValue, Object endValue);

    /**
     * 范围条件
     *
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    C in(String leftField, String... rightFields);

    /**
     * 范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    C in(Enum<?> leftField, Enum<?>... rightFields);

    /**
     * 范围条件
     *
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    C in(String leftField, Collection<String> rightFields);

    /**
     * 范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    C in(Enum<?> leftField, Collection<Enum<?>> rightFields);

    /**
     * 范围条件
     *
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    C in(String leftField, Collection<String> rightFields, Collection<?> rightValues);

    /**
     * 范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C in(Enum<?> leftField, Collection<Enum<?>> rightFields, Collection<?> rightValues);

    /**
     * 范围条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C in(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 范围条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C in(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 范围条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C in(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 范围条件
     *
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    C inValue(String leftField, Object... rightValues);

    /**
     * 范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C inValue(Enum<?> leftField, Object... rightValues);

    /**
     * 范围条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C inValue(String leftTableAlias, Enum<?> leftField, Object... rightValues);

    /**
     * 范围条件
     *
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    C inValue(String leftField, Collection<?> rightValues);

    /**
     * 范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C inValue(Enum<?> leftField, Collection<?> rightValues);

    /**
     * 范围条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C inValue(String leftTableAlias, Enum<?> leftField, Collection<?> rightValues);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    C notIn(String leftField, String... rightFields);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    C notIn(Enum<?> leftField, Enum<?>... rightFields);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    C notIn(String leftField, Collection<String> rightFields);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    C notIn(Enum<?> leftField, Collection<Enum<?>> rightFields);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notIn(String leftField, Collection<String> rightFields, Collection<?> rightValues);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notIn(Enum<?> leftField, Collection<Enum<?>> rightFields, Collection<?> rightValues);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C notIn(String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C notIn(Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 非范围条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C notIn(String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notInValue(String leftField, Object... rightValues);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notInValue(Enum<?> leftField, Object... rightValues);

    /**
     * 非范围条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notInValue(String leftTableAlias, Enum<?> leftField, Object... rightValues);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notInValue(String leftField, Collection<?> rightValues);

    /**
     * 非范围条件
     *
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notInValue(Enum<?> leftField, Collection<?> rightValues);

    /**
     * 非范围条件
     *
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    C notInValue(String leftTableAlias, Enum<?> leftField, Collection<?> rightValues);

    /**
     * 为空条件
     *
     * @param field 字段名称
     * @return 具体实现
     */
    C isNull(String field);

    /**
     * 为空条件
     *
     * @param field 字段枚举
     * @return 具体实现
     */
    C isNull(Enum<?> field);

    /**
     * 为空条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @return 具体实现
     */
    C isNull(String tableAlias, Enum<?> field);

    /**
     * 为空条件
     *
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C isNull(Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 非空条件
     *
     * @param field 字段名称
     * @return 具体实现
     */
    C isNotNull(String field);

    /**
     * 非空条件
     *
     * @param field 字段枚举
     * @return 具体实现
     */
    C isNotNull(Enum<?> field);

    /**
     * 非空条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @return 具体实现
     */
    C isNotNull(String tableAlias, Enum<?> field);

    /**
     * 非空条件
     *
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    C isNotNull(Consumer<StandardSelectSql> sqlBuilderConsumer);

    /**
     * 模糊匹配条件
     *
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    C like(String field, String value);

    /**
     * 模糊匹配条件
     *
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C like(Enum<?> field, String value);

    /**
     * 模糊匹配条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C like(String tableAlias, Enum<?> field, String value);

    /**
     * 左模糊匹配条件
     *
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    C likeLeft(String field, String value);

    /**
     * 左模糊匹配条件
     *
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C likeLeft(Enum<?> field, String value);

    /**
     * 左模糊匹配条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C likeLeft(String tableAlias, Enum<?> field, String value);

    /**
     * 右模糊匹配条件
     *
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    C likeRight(String field, String value);

    /**
     * 右模糊匹配条件
     *
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C likeRight(Enum<?> field, String value);

    /**
     * 右模糊匹配条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C likeRight(String tableAlias, Enum<?> field, String value);

    /**
     * 非模糊匹配条件
     *
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    C notLike(String field, String value);

    /**
     * 非模糊匹配条件
     *
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C notLike(Enum<?> field, String value);

    /**
     * 非模糊匹配条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C notLike(String tableAlias, Enum<?> field, String value);

    /**
     * 非左模糊匹配条件
     *
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    C notLikeLeft(String field, String value);

    /**
     * 非左模糊匹配条件
     *
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C notLikeLeft(Enum<?> field, String value);

    /**
     * 非左模糊匹配条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C notLikeLeft(String tableAlias, Enum<?> field, String value);

    /**
     * 非右模糊匹配条件
     *
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    C notLikeRight(String field, String value);

    /**
     * 非右模糊匹配条件
     *
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C notLikeRight(Enum<?> field, String value);

    /**
     * 非右模糊匹配条件
     *
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    C notLikeRight(String tableAlias, Enum<?> field, String value);

    /**
     * 表达式匹配条件
     *
     * @param expression 表达式
     * @param args 表达式参数
     * @return 具体实现
     */
    C expression(String expression, Object... args);

    /**
     * 嵌套条件
     *
     * @return 条件嵌套器
     */
    AbstractNestCondition<C> nest();

    /**
     * 开始或条件
     *
     * @return 或条件构建器
     */
    AbstractOrCondition<C> or();

    /* 带条件方法 */

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C eq(boolean condition, String leftField, String rightField) {
        if (condition) {
            return this.eq(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C eq(boolean condition, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.eq(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C eq(boolean condition, String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.eq(leftTableAlias, leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C eq(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.eq(leftTableAlias, leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C eq(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.eq(leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C eq(boolean condition, String leftField, Enum<?> rightField) {
        if (condition) {
            return this.eq(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C eq(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.eq(leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C eq(boolean condition, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.eq(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C eq(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.eq(leftTableAlias, leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C eq(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.eq(leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C eq(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.eq(leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C eq(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.eq(leftTableAlias, leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C eqValue(boolean condition, String leftField, Object rightValue) {
        if (condition) {
            return this.eqValue(leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C eqValue(boolean condition, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.eqValue(leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C eqValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.eqValue(leftTableAlias, leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C ne(boolean condition, String leftField, String rightField) {
        if (condition) {
            return this.ne(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ne(boolean condition, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.ne(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ne(boolean condition, String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.ne(leftTableAlias, leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ne(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.ne(leftTableAlias, leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ne(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.ne(leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ne(boolean condition, String leftField, Enum<?> rightField) {
        if (condition) {
            return this.ne(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ne(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.ne(leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C ne(boolean condition, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.ne(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C ne(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.ne(leftTableAlias, leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C ne(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.ne(leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C ne(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.ne(leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C ne(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.ne(leftTableAlias, leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C neValue(boolean condition, String leftField, Object rightValue) {
        if (condition) {
            return this.neValue(leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C neValue(boolean condition, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.neValue(leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 不相等条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C neValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.neValue(leftTableAlias, leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C lt(boolean condition, String leftField, String rightField) {
        if (condition) {
            return this.lt(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C lt(boolean condition, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.lt(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C lt(boolean condition, String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.lt(leftTableAlias, leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C lt(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.lt(leftTableAlias, leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C lt(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.lt(leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C lt(boolean condition, String leftField, Enum<?> rightField) {
        if (condition) {
            return this.lt(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C lt(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.lt(leftField, rightTableAlias, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C lt(boolean condition, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.lt(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C lt(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.lt(leftTableAlias, leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C lt(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.lt(leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C lt(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.lt(leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C lt(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.lt(leftTableAlias, leftField, sqlBuilderConsumer);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C ltValue(boolean condition, String leftField, Object rightValue) {
        if (condition) {
            return this.ltValue(leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C ltValue(boolean condition, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.ltValue(leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 小于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C ltValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.ltValue(leftTableAlias, leftField, rightValue);
        }

        return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C le(boolean condition, String leftField, String rightField) {
        if (condition) {
            return this.le(leftField, rightField);
        }

        return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C le(boolean condition, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.le(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C le(boolean condition, String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.le(leftTableAlias, leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C le(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.le(leftTableAlias, leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C le(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.le(leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C le(boolean condition, String leftField, Enum<?> rightField) {
        if (condition) {
            return this.le(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C le(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.le(leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C le(boolean condition, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.le(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C le(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.le(leftTableAlias, leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C le(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.le(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C le(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.le(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C le(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.le(leftTableAlias, leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C leValue(boolean condition, String leftField, Object rightValue) {
        if (condition) {
            return this.leValue(leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C leValue(boolean condition, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.leValue(leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 小于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C leValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.leValue(leftTableAlias, leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C gt(boolean condition, String leftField, String rightField) {
        if (condition) {
            return this.gt(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C gt(boolean condition, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.gt(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C gt(boolean condition, String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.gt(leftTableAlias, leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C gt(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.gt(leftTableAlias, leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C gt(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.gt(leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C gt(boolean condition, String leftField, Enum<?> rightField) {
        if (condition) {
            return this.gt(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C gt(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.gt(leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C gt(boolean condition, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.gt(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C gt(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.gt(leftTableAlias, leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C gt(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.gt(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C gt(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.gt(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C gt(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.gt(leftTableAlias, leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C gtValue(boolean condition, String leftField, Object rightValue) {
        if (condition) {
            return this.gtValue(leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C gtValue(boolean condition, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.gtValue(leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 大于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C gtValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.gtValue(leftTableAlias, leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C ge(boolean condition, String leftField, String rightField) {
        if (condition) {
            return this.ge(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ge(boolean condition, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.ge(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ge(boolean condition, String leftTableAlias, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.ge(leftTableAlias, leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ge(boolean condition, String leftTableAlias, Enum<?> leftField, Enum<?> rightField) {
        if (condition) {
            return this.ge(leftTableAlias, leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ge(boolean condition, Enum<?> leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.ge(leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ge(boolean condition, String leftField, Enum<?> rightField) {
        if (condition) {
            return this.ge(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightTableAlias 右边字段表别名
     * @param rightField 右边字段枚举
     * @return 具体实现
     */
    default C ge(boolean condition, String leftField, String rightTableAlias, Enum<?> rightField) {
        if (condition) {
            return this.ge(leftField, rightTableAlias, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C ge(boolean condition, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.ge(leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightField 右边字段名称
     * @return 具体实现
     */
    default C ge(boolean condition, String leftTableAlias, Enum<?> leftField, String rightField) {
        if (condition) {
            return this.ge(leftTableAlias, leftField, rightField);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C ge(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.ge(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C ge(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.ge(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C ge(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.ge(leftTableAlias, leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C geValue(boolean condition, String leftField, Object rightValue) {
        if (condition) {
            return this.geValue(leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C geValue(boolean condition, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.geValue(leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 大于等于条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValue 右边值
     * @return 具体实现
     */
    default C geValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object rightValue) {
        if (condition) {
            return this.geValue(leftTableAlias, leftField, rightValue);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    default C between(boolean condition, String leftField, String beginField, String endField) {
        if (condition) {
            return this.between(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C between(boolean condition, String leftField, Enum<?> beginField, Enum<?> endField) {
        if (condition) {
            return this.between(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C between(boolean condition, String leftField, String beginField, Enum<?> endField) {
        if (condition) {
            return this.between(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    default C between(boolean condition, String leftField, Enum<?> beginField, String endField) {
        if (condition) {
            return this.between(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C between(boolean condition, Enum<?> leftField, Enum<?> beginField, Enum<?> endField) {
        if (condition) {
            return this.between(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C between(boolean condition, Enum<?> leftField, String beginField, Enum<?> endField) {
        if (condition) {
            return this.between(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段
     * @return 具体实现
     */
    default C between(boolean condition, Enum<?> leftField, Enum<?> beginField, String endField) {
        if (condition) {
            return this.between(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    default C betweenBeginValue(boolean condition, String leftField, Object beginValue, String endField) {
        if (condition) {
            return this.betweenBeginValue(leftField, beginValue, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C betweenBeginValue(boolean condition, Enum<?> leftField, Object beginValue, Enum<?> endField) {
        if (condition) {
            return this.betweenBeginValue(leftField, beginValue, endField);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C betweenEndValue(boolean condition, String leftField, String beginField, Object endValue) {
        if (condition) {
            return this.betweenEndValue(leftField, beginField, endValue);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C betweenEndValue(boolean condition, Enum<?> leftField, Enum<?> beginField, Object endValue) {
        if (condition) {
            return this.betweenEndValue(leftField, beginField, endValue);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C betweenValue(boolean condition, String leftField, Object beginValue, Object endValue) {
        if (condition) {
            return this.betweenValue(leftField, beginValue, endValue);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C betweenValue(boolean condition, Enum<?> leftField, Object beginValue, Object endValue) {
        if (condition) {
            return this.betweenValue(leftField, beginValue, endValue);
        }

       return (C) this;
    }

    /**
     * 区间条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C betweenValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object beginValue, Object endValue) {
        if (condition) {
            return this.betweenValue(leftTableAlias, leftField, beginValue, endValue);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    default C notBetween(boolean condition, String leftField, String beginField, String endField) {
        if (condition) {
            return this.notBetween(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C notBetween(boolean condition, String leftField, Enum<?> beginField, Enum<?> endField) {
        if (condition) {
            return this.notBetween(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C notBetween(boolean condition, String leftField, String beginField, Enum<?> endField) {
        if (condition) {
            return this.notBetween(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    default C notBetween(boolean condition, String leftField, Enum<?> beginField, String endField) {
        if (condition) {
            return this.notBetween(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C notBetween(boolean condition, Enum<?> leftField, Enum<?> beginField, Enum<?> endField) {
        if (condition) {
            return this.notBetween(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段名称
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C notBetween(boolean condition, Enum<?> leftField, String beginField, Enum<?> endField) {
        if (condition) {
            return this.notBetween(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    default C notBetween(boolean condition, Enum<?> leftField, Enum<?> beginField, String endField) {
        if (condition) {
            return this.notBetween(leftField, beginField, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endField 区间结束字段名称
     * @return 具体实现
     */
    default C notBetweenBeginValue(boolean condition, String leftField, Object beginValue, String endField) {
        if (condition) {
            return this.notBetweenBeginValue(leftField, beginValue, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endField 区间结束字段枚举
     * @return 具体实现
     */
    default C notBetweenBeginValue(boolean condition, Enum<?> leftField, Object beginValue, Enum<?> endField) {
        if (condition) {
            return this.notBetweenBeginValue(leftField, beginValue, endField);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginField 区间开始字段名称
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C notBetweenEndValue(boolean condition, String leftField, String beginField, Object endValue) {
        if (condition) {
            return this.notBetweenEndValue(leftField, beginField, endValue);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginField 区间开始字段枚举
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C notBetweenEndValue(boolean condition, Enum<?> leftField, Enum<?> beginField, Object endValue) {
        if (condition) {
            return this.notBetweenEndValue(leftField, beginField, endValue);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C notBetweenValue(boolean condition, String leftField, Object beginValue, Object endValue) {
        if (condition) {
            return this.notBetweenValue(leftField, beginValue, endValue);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C notBetweenValue(boolean condition, Enum<?> leftField, Object beginValue, Object endValue) {
        if (condition) {
            return this.notBetweenValue(leftField, beginValue, endValue);
        }

       return (C) this;
    }

    /**
     * 非区间条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param beginValue 区间开始值
     * @param endValue 区间结束值
     * @return 具体实现
     */
    default C notBetweenValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object beginValue, Object endValue) {
        if (condition) {
            return this.notBetweenValue(leftTableAlias, leftField, beginValue, endValue);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    default C in(boolean condition, String leftField, String... rightFields) {
        if (condition) {
            return this.in(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    default C in(boolean condition, Enum<?> leftField, Enum<?>... rightFields) {
        if (condition) {
            return this.in(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    default C in(boolean condition, String leftField, Collection<String> rightFields) {
        if (condition) {
            return this.in(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    default C in(boolean condition, Enum<?> leftField, Collection<Enum<?>> rightFields) {
        if (condition) {
            return this.in(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C in(boolean condition, String leftField, Collection<String> rightFields, Collection<?> rightValues) {
        if (condition) {
            return this.in(leftField, rightFields, rightValues);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C in(boolean condition, Enum<?> leftField, Collection<Enum<?>> rightFields, Collection<?> rightValues) {
        if (condition) {
            return this.in(leftField, rightFields, rightValues);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C in(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.in(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C in(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.in(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C in(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.in(leftTableAlias, leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C inValue(boolean condition, String leftField, Object... rightValues) {
        if (condition) {
            return this.inValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C inValue(boolean condition, Enum<?> leftField, Object... rightValues) {
        if (condition) {
            return this.inValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C inValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object... rightValues) {
        if (condition) {
            return this.inValue(leftTableAlias, leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C inValue(boolean condition, String leftField, Collection<?> rightValues) {
        if (condition) {
            return this.inValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C inValue(boolean condition, Enum<?> leftField, Collection<?> rightValues) {
        if (condition) {
            return this.inValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 范围条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C inValue(boolean condition, String leftTableAlias, Enum<?> leftField, Collection<?> rightValues) {
        if (condition) {
            return this.inValue(leftTableAlias, leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    default C notIn(boolean condition, String leftField, String... rightFields) {
        if (condition) {
            return this.notIn(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    default C notIn(boolean condition, Enum<?> leftField, Enum<?>... rightFields) {
        if (condition) {
            return this.notIn(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @return 具体实现
     */
    default C notIn(boolean condition, String leftField, Collection<String> rightFields) {
        if (condition) {
            return this.notIn(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @return 具体实现
     */
    default C notIn(boolean condition, Enum<?> leftField, Collection<Enum<?>> rightFields) {
        if (condition) {
            return this.notIn(leftField, rightFields);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightFields 范围字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notIn(boolean condition, String leftField, Collection<String> rightFields, Collection<?> rightValues) {
        if (condition) {
            return this.notIn(leftField, rightFields, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightFields 范围字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notIn(boolean condition, Enum<?> leftField, Collection<Enum<?>> rightFields, Collection<?> rightValues) {
        if (condition) {
            return this.notIn(leftField, rightFields, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C notIn(boolean condition, String leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.notIn(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C notIn(boolean condition, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.notIn(leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C notIn(boolean condition, String leftTableAlias, Enum<?> leftField, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.notIn(leftTableAlias, leftField, sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notInValue(boolean condition, String leftField, Object... rightValues) {
        if (condition) {
            return this.notInValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notInValue(boolean condition, Enum<?> leftField, Object... rightValues) {
        if (condition) {
            return this.notInValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notInValue(boolean condition, String leftTableAlias, Enum<?> leftField, Object... rightValues) {
        if (condition) {
            return this.notInValue(leftTableAlias, leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段名称
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notInValue(boolean condition, String leftField, Collection<?> rightValues) {
        if (condition) {
            return this.notInValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notInValue(boolean condition, Enum<?> leftField, Collection<?> rightValues) {
        if (condition) {
            return this.notInValue(leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 非范围条件
     *
     * @param condition 条件
     * @param leftTableAlias 左边字段表别名
     * @param leftField 左边字段枚举
     * @param rightValues 范围值
     * @return 具体实现
     */
    default C notInValue(boolean condition, String leftTableAlias, Enum<?> leftField, Collection<?> rightValues) {
        if (condition) {
            return this.notInValue(leftTableAlias, leftField, rightValues);
        }

       return (C) this;
    }

    /**
     * 为空条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @return 具体实现
     */
    default C isNull(boolean condition, String field) {
        if (condition) {
            return this.isNull(field);
        }

       return (C) this;
    }

    /**
     * 为空条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @return 具体实现
     */
    default C isNull(boolean condition, Enum<?> field) {
        if (condition) {
            return this.isNull(field);
        }

       return (C) this;
    }

    /**
     * 为空条件
     *
     * @param condition 条件
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @return 具体实现
     */
    default C isNull(boolean condition, String tableAlias, Enum<?> field) {
        if (condition) {
            return this.isNull(tableAlias, field);
        }

       return (C) this;
    }

    /**
     * 为空条件
     *
     * @param condition 条件
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C isNull(boolean condition, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.isNull(sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 非空条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @return 具体实现
     */
    default C isNotNull(boolean condition, String field) {
        if (condition) {
            return this.isNotNull(field);
        }

       return (C) this;
    }

    /**
     * 非空条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @return 具体实现
     */
    default C isNotNull(boolean condition, Enum<?> field) {
        if (condition) {
            return this.isNotNull(field);
        }

       return (C) this;
    }

    /**
     * 非空条件
     *
     * @param condition 条件
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @return 具体实现
     */
    default C isNotNull(boolean condition, String tableAlias, Enum<?> field) {
        if (condition) {
            return this.isNotNull(tableAlias, field);
        }

       return (C) this;
    }

    /**
     * 非空条件
     *
     * @param condition 条件
     * @param sqlBuilderConsumer SQL构建器消费器
     * @return 具体实现
     */
    default C isNotNull(boolean condition, Consumer<StandardSelectSql> sqlBuilderConsumer) {
        if (condition) {
            return this.isNotNull(sqlBuilderConsumer);
        }

       return (C) this;
    }

    /**
     * 模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    default C like(boolean condition, String field, String value) {
        if (condition) {
            return this.like(field, value);
        }

       return (C) this;
    }

    /**
     * 模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C like(boolean condition, Enum<?> field, String value) {
        if (condition) {
            return this.like(field, value);
        }

       return (C) this;
    }

    /**
     * 模糊匹配条件
     *
     * @param condition 条件
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C like(boolean condition, String tableAlias, Enum<?> field, String value) {
        if (condition) {
            return this.like(tableAlias, field, value);
        }

       return (C) this;
    }

    /**
     * 左模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    default C likeLeft(boolean condition, String field, String value) {
        if (condition) {
            return this.likeLeft(field, value);
        }

       return (C) this;
    }

    /**
     * 左模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C likeLeft(boolean condition, Enum<?> field, String value) {
        if (condition) {
            return this.likeLeft(field, value);
        }

       return (C) this;
    }

    /**
     * 左模糊匹配条件
     *
     * @param condition 条件
     * @param tableAlias 表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C likeLeft(boolean condition, String tableAlias, Enum<?> field, String value) {
        if (condition) {
            return this.likeLeft(tableAlias, field, value);
        }

       return (C) this;
    }

    /**
     * 右模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    default C likeRight(boolean condition, String field, String value) {
        if (condition) {
            return this.likeRight(field, value);
        }

       return (C) this;
    }

    /**
     * 右模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C likeRight(boolean condition, Enum<?> field, String value) {
        if (condition) {
            return this.likeRight(field, value);
        }

       return (C) this;
    }

    /**
     * 右模糊匹配条件
     *
     * @param condition 条件
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C likeRight(boolean condition, String tableAlias, Enum<?> field, String value) {
        if (condition) {
            return this.likeRight(tableAlias, field, value);
        }

       return (C) this;
    }

    /**
     * 非模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLike(boolean condition, String field, String value) {
        if (condition) {
            return this.notLike(field, value);
        }

       return (C) this;
    }

    /**
     * 非模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLike(boolean condition, Enum<?> field, String value) {
        if (condition) {
            return this.notLike(field, value);
        }

       return (C) this;
    }

    /**
     * 非模糊匹配条件
     *
     * @param condition 条件
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLike(boolean condition, String tableAlias, Enum<?> field, String value) {
        if (condition) {
            return this.notLike(tableAlias, field, value);
        }

       return (C) this;
    }

    /**
     * 非左模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLikeLeft(boolean condition, String field, String value) {
        if (condition) {
            return this.notLikeLeft(field, value);
        }

       return (C) this;
    }

    /**
     * 非左模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLikeLeft(boolean condition, Enum<?> field, String value) {
        if (condition) {
            return this.notLikeLeft(field, value);
        }

       return (C) this;
    }

    /**
     * 非左模糊匹配条件
     *
     * @param condition 条件
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLikeLeft(boolean condition, String tableAlias, Enum<?> field, String value) {
        if (condition) {
            return this.notLikeLeft(tableAlias, field, value);
        }

       return (C) this;
    }

    /**
     * 非右模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段名称
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLikeRight(boolean condition, String field, String value) {
        if (condition) {
            return this.notLikeRight(field, value);
        }

       return (C) this;
    }

    /**
     * 非右模糊匹配条件
     *
     * @param condition 条件
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLikeRight(boolean condition, Enum<?> field, String value) {
        if (condition) {
            return this.notLikeRight(field, value);
        }

       return (C) this;
    }

    /**
     * 非右模糊匹配条件
     *
     * @param condition 条件
     * @param tableAlias 字段表别名
     * @param field 字段枚举
     * @param value 匹配值
     * @return 具体实现
     */
    default C notLikeRight(boolean condition, String tableAlias, Enum<?> field, String value) {
        if (condition) {
            return this.notLikeRight(tableAlias, field, value);
        }

       return (C) this;
    }

    /**
     * 表达式匹配条件
     *
     * @param condition 条件
     * @param expression 表达式
     * @param args 表达式参数
     * @return 具体实现
     */
    default C expression(boolean condition, String expression, Object... args) {
        if (condition) {
            return this.expression(expression, args);
        }

       return (C) this;
    }
}
